import * as os from 'os';
import * as vscode from 'vscode';
import { exec } from 'child_process';
import { promisify } from 'util';

const execAsync = promisify(exec);

/**
 * 平台类型枚举
 */
export enum PlatformType {
    WINDOWS = 'windows',
    MACOS = 'macos',
    LINUX = 'linux',
    WSL = 'wsl'
}

/**
 * 平台帮助工具类 - 处理各平台特定的功能和兼容性问题
 */
export class PlatformHelper {
    private static instance: PlatformHelper;
    private platformType: PlatformType;
    private isWSL: boolean = false;
    private isRootless: boolean = false;
    private isAdmin: boolean = false;

    private constructor() {
        // 初始化时检测平台类型
        const platform = os.platform();
        
        if (platform === 'win32') {
            this.platformType = PlatformType.WINDOWS;
        } else if (platform === 'darwin') {
            this.platformType = PlatformType.MACOS;
        } else if (platform === 'linux') {
            this.platformType = PlatformType.LINUX;
        } else {
            // 默认为 Linux
            this.platformType = PlatformType.LINUX;
        }
        
        // 在初始化时进一步探测 WSL 环境
        this.detectWSLAsync();
    }

    /**
     * 获取单例实例
     */
    public static getInstance(): PlatformHelper {
        if (!PlatformHelper.instance) {
            PlatformHelper.instance = new PlatformHelper();
        }
        return PlatformHelper.instance;
    }

    /**
     * 获取平台类型
     */
    public getPlatformType(): PlatformType {
        return this.platformType;
    }

    /**
     * 是否是 Windows 操作系统
     */
    public isWindows(): boolean {
        return this.platformType === PlatformType.WINDOWS;
    }

    /**
     * 是否是 macOS 操作系统
     */
    public isMacOS(): boolean {
        return this.platformType === PlatformType.MACOS;
    }

    /**
     * 是否是 Linux 操作系统
     */
    public isLinux(): boolean {
        return this.platformType === PlatformType.LINUX;
    }

    /**
     * 是否是 WSL 环境
     */
    public isWSLEnvironment(): boolean {
        return this.isWSL;
    }

    /**
     * 是否是无根容器环境（更安全）
     */
    public isRootlessEnvironment(): boolean {
        return this.isRootless;
    }

    /**
     * 是否以管理员权限运行
     */
    public isAdminPrivileged(): boolean {
        return this.isAdmin;
    }

    /**
     * 异步检测 WSL 环境
     */
    private async detectWSLAsync(): Promise<void> {
        try {
            if (this.platformType === PlatformType.LINUX) {
                // 检查是否在 WSL 环境中运行
                const { stdout } = await execAsync('cat /proc/version');
                this.isWSL = stdout.toLowerCase().includes('microsoft') || stdout.toLowerCase().includes('wsl');
                
                if (this.isWSL) {
                    this.platformType = PlatformType.WSL;
                }
            }
        } catch (error) {
            console.log('WSL detection error:', error);
            this.isWSL = false;
        }
    }

    /**
     * 检查当前用户权限（rootless/admin）
     */
    public async checkUserPrivileges(): Promise<void> {
        try {
            if (this.isWindows()) {
                // Windows 权限检查
                const { stdout } = await execAsync('net session >nul 2>&1 && echo admin || echo standard');
                this.isAdmin = stdout.trim() === 'admin';
            } else {
                // macOS/Linux 权限检查
                const { stdout } = await execAsync('id -u');
                this.isAdmin = stdout.trim() === '0';
            }
            
            // 检查容器运行时是否为 rootless 模式
            await this.checkRootlessContainerRuntime();
        } catch (error) {
            console.log('User privileges check error:', error);
            this.isAdmin = false;
        }
    }

    /**
     * 检查容器运行时是否为 rootless 模式
     */
    private async checkRootlessContainerRuntime(): Promise<void> {
        try {
            // 检查 Docker 是否运行在 rootless 模式
            const { stdout: dockerInfo } = await execAsync('docker info 2>/dev/null || echo "Docker not available"');
            this.isRootless = dockerInfo.includes('rootless') || dockerInfo.includes('Rootless');
            
            if (!this.isRootless) {
                // 如果 Docker 不是 rootless 模式，检查 Podman
                try {
                    const { stdout: podmanInfo } = await execAsync('podman info 2>/dev/null || echo "Podman not available"');
                    // Podman 默认是 rootless 的，但我们仍然明确检查
                    this.isRootless = podmanInfo.includes('rootless') || !podmanInfo.includes('Podman not available');
                } catch {
                    // Podman 可能不可用，保持之前的值
                }
            }
        } catch (error) {
            console.log('Rootless check error:', error);
            this.isRootless = false;
        }
    }

    /**
     * 验证端口权限（在类 Unix 系统上，低于 1024 的端口需要特权）
     */
    public isPrivilegedPort(port: number): boolean {
        // Windows 没有特权端口的概念
        if (this.isWindows()) {
            return false;
        }
        
        // 在 Unix 系统上，小于 1024 的端口被认为是特权端口
        return port < 1024;
    }

    /**
     * 建议可用的非特权端口
     */
    public suggestNonPrivilegedPort(desiredPort: number): number {
        if (desiredPort >= 1024) {
            return desiredPort; // 已经是非特权端口
        }
        
        // 为特权端口建议一个替代端口
        const portMap: Record<number, number> = {
            80: 8080,
            443: 8443,
            21: 2121,
            22: 2222,
            25: 2525
        };
        
        return portMap[desiredPort] || 8000 + desiredPort;
    }

    /**
     * 获取平台特定的 Docker/Podman 卷挂载路径转换
     * WSL 和 Windows 之间的路径转换需要特殊处理
     */
    public async convertPathForContainer(originalPath: string): Promise<string> {
        try {
            if (this.isWSL) {
                // 如果是 WSL 环境，需要将路径转换为 Windows 路径
                const { stdout } = await execAsync(`wslpath -w "${originalPath}"`);
                return stdout.trim();
            } else if (this.isWindows()) {
                // Windows 环境下，需要处理路径分隔符
                return originalPath.replace(/\\/g, '/');
            } else {
                // macOS 和 Linux 可以直接使用路径
                return originalPath;
            }
        } catch (error) {
            console.error('Path conversion error:', error);
            return originalPath; // 转换失败时返回原路径
        }
    }

    /**
     * 显示端口权限处理指南
     */
    public async showPortPermissionGuide(port: number): Promise<void> {
        if (!this.isPrivilegedPort(port)) {
            return; // 非特权端口不需要处理
        }
        
        let message: string;
        let actions: string[] = [];
        
        if (this.isMacOS()) {
            message = `端口 ${port} 需要管理员权限。在 macOS 上，您有以下选择:`;
            actions = ['使用端口转发', '使用非特权端口', '查看详细指南'];
        } else if (this.isLinux() || this.isWSLEnvironment()) {
            message = `端口 ${port} 需要管理员权限。在 ${this.isWSLEnvironment() ? 'WSL' : 'Linux'} 上，您有以下选择:`;
            actions = ['使用端口转发', '使用非特权端口', '修改系统配置', '查看详细指南'];
        } else {
            // Windows 不存在这个问题
            return;
        }
        
        const selection = await vscode.window.showInformationMessage(message, ...actions);
        
        switch (selection) {
            case '使用端口转发':
                const suggestedPort = this.suggestNonPrivilegedPort(port);
                vscode.window.showInformationMessage(
                    `您可以使用 ${suggestedPort} 端口，并在 Nginx 配置中将 ${port} 端口的请求转发到 ${suggestedPort}`
                );
                break;
                
            case '使用非特权端口':
                const newPort = this.suggestNonPrivilegedPort(port);
                vscode.window.showInformationMessage(`建议使用非特权端口 ${newPort} 替代 ${port}`);
                break;
                
            case '修改系统配置':
                if (this.isLinux() || this.isWSLEnvironment()) {
                    vscode.window.showInformationMessage(
                        '可以使用以下命令允许非root用户绑定到特权端口: ' +
                        'sudo setcap cap_net_bind_service=+ep `which nginx`'
                    );
                }
                break;
                
            case '查看详细指南':
                // 打开详细文档
                vscode.commands.executeCommand('vscode.open', vscode.Uri.parse('https://nginx.org/en/docs/beginners_guide.html'));
                break;
        }
    }

    /**
     * 获取平台特定的 Docker 或 Podman 命令选项
     */
    public getContainerOptions(containerType: 'docker' | 'podman'): Record<string, string> {
        const options: Record<string, string> = {};
        
        if (this.isWSLEnvironment() && containerType === 'docker') {
            // WSL 环境中的 Docker 需要特殊处理
            options.host = '-H npipe:////./pipe/docker_engine';
        }
        
        if (this.isWindows() && containerType === 'podman') {
            // Windows 环境下的 Podman 可能需要特殊处理
            options.connection = '--connection podman-machine-default';
        }
        
        return options;
    }
} 